home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / util / EnumMap.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  6.6 KB  |  301 lines
  1. package java.util;
  2.  
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.ObjectOutputStream;
  6. import java.io.Serializable;
  7. import sun.misc.SharedSecrets;
  8.  
  9. public class EnumMap<K extends Enum<K>, V> extends AbstractMap<K, V> implements Serializable, Cloneable {
  10.    private final Class<K> keyType;
  11.    private transient K[] keyUniverse;
  12.    private transient Object[] vals;
  13.    private transient int size = 0;
  14.    private static final Object NULL = new Object();
  15.    private static Enum[] ZERO_LENGTH_ENUM_ARRAY = new Enum[0];
  16.    private transient Set<Map.Entry<K, V>> entrySet = null;
  17.    private static final long serialVersionUID = 458661240069192865L;
  18.  
  19.    private Object maskNull(Object var1) {
  20.       return var1 == null ? NULL : var1;
  21.    }
  22.  
  23.    private V unmaskNull(Object var1) {
  24.       return (V)(var1 == NULL ? null : var1);
  25.    }
  26.  
  27.    public EnumMap(Class<K> var1) {
  28.       this.keyType = var1;
  29.       this.keyUniverse = getKeyUniverse(var1);
  30.       this.vals = new Object[this.keyUniverse.length];
  31.    }
  32.  
  33.    public EnumMap(EnumMap<K, ? extends V> var1) {
  34.       this.keyType = var1.keyType;
  35.       this.keyUniverse = var1.keyUniverse;
  36.       this.vals = var1.vals.clone();
  37.       this.size = var1.size;
  38.    }
  39.  
  40.    public EnumMap(Map<K, ? extends V> var1) {
  41.       if (var1 instanceof EnumMap) {
  42.          EnumMap var2 = (EnumMap)var1;
  43.          this.keyType = var2.keyType;
  44.          this.keyUniverse = var2.keyUniverse;
  45.          this.vals = var2.vals.clone();
  46.          this.size = var2.size;
  47.       } else {
  48.          if (var1.isEmpty()) {
  49.             throw new IllegalArgumentException("Specified map is empty");
  50.          }
  51.  
  52.          this.keyType = ((Enum)var1.keySet().iterator().next()).getDeclaringClass();
  53.          this.keyUniverse = getKeyUniverse(this.keyType);
  54.          this.vals = new Object[this.keyUniverse.length];
  55.          this.putAll(var1);
  56.       }
  57.  
  58.    }
  59.  
  60.    public int size() {
  61.       return this.size;
  62.    }
  63.  
  64.    public boolean containsValue(Object var1) {
  65.       var1 = this.maskNull(var1);
  66.  
  67.       for(Object var5 : this.vals) {
  68.          if (var1.equals(var5)) {
  69.             return true;
  70.          }
  71.       }
  72.  
  73.       return false;
  74.    }
  75.  
  76.    public boolean containsKey(Object var1) {
  77.       return this.isValidKey(var1) && this.vals[((Enum)var1).ordinal()] != null;
  78.    }
  79.  
  80.    private boolean containsMapping(Object var1, Object var2) {
  81.       return this.isValidKey(var1) && this.maskNull(var2).equals(this.vals[((Enum)var1).ordinal()]);
  82.    }
  83.  
  84.    public V get(Object var1) {
  85.       return (V)(this.isValidKey(var1) ? this.unmaskNull(this.vals[((Enum)var1).ordinal()]) : null);
  86.    }
  87.  
  88.    public V put(K var1, V var2) {
  89.       this.typeCheck(var1);
  90.       int var3 = var1.ordinal();
  91.       Object var4 = this.vals[var3];
  92.       this.vals[var3] = this.maskNull(var2);
  93.       if (var4 == null) {
  94.          ++this.size;
  95.       }
  96.  
  97.       return (V)this.unmaskNull(var4);
  98.    }
  99.  
  100.    public V remove(Object var1) {
  101.       if (!this.isValidKey(var1)) {
  102.          return null;
  103.       } else {
  104.          int var2 = ((Enum)var1).ordinal();
  105.          Object var3 = this.vals[var2];
  106.          this.vals[var2] = null;
  107.          if (var3 != null) {
  108.             --this.size;
  109.          }
  110.  
  111.          return (V)this.unmaskNull(var3);
  112.       }
  113.    }
  114.  
  115.    private boolean removeMapping(Object var1, Object var2) {
  116.       if (!this.isValidKey(var1)) {
  117.          return false;
  118.       } else {
  119.          int var3 = ((Enum)var1).ordinal();
  120.          if (this.maskNull(var2).equals(this.vals[var3])) {
  121.             this.vals[var3] = null;
  122.             --this.size;
  123.             return true;
  124.          } else {
  125.             return false;
  126.          }
  127.       }
  128.    }
  129.  
  130.    private boolean isValidKey(Object var1) {
  131.       if (var1 == null) {
  132.          return false;
  133.       } else {
  134.          Class var2 = var1.getClass();
  135.          return var2 == this.keyType || var2.getSuperclass() == this.keyType;
  136.       }
  137.    }
  138.  
  139.    public void putAll(Map<? extends K, ? extends V> var1) {
  140.       if (var1 instanceof EnumMap) {
  141.          EnumMap var2 = (EnumMap)var1;
  142.          if (var2.keyType != this.keyType) {
  143.             if (var2.isEmpty()) {
  144.                return;
  145.             }
  146.  
  147.             throw new ClassCastException(var2.keyType + " != " + this.keyType);
  148.          }
  149.  
  150.          for(int var3 = 0; var3 < this.keyUniverse.length; ++var3) {
  151.             Object var4 = var2.vals[var3];
  152.             if (var4 != null) {
  153.                if (this.vals[var3] == null) {
  154.                   ++this.size;
  155.                }
  156.  
  157.                this.vals[var3] = var4;
  158.             }
  159.          }
  160.       } else {
  161.          super.putAll(var1);
  162.       }
  163.  
  164.    }
  165.  
  166.    public void clear() {
  167.       Arrays.fill(this.vals, (Object)null);
  168.       this.size = 0;
  169.    }
  170.  
  171.    public Set<K> keySet() {
  172.       Set var1 = this.keySet;
  173.       return var1 != null ? var1 : (this.keySet = new KeySet(this, (1)null));
  174.    }
  175.  
  176.    public Collection<V> values() {
  177.       Collection var1 = this.values;
  178.       return var1 != null ? var1 : (this.values = new Values(this, (1)null));
  179.    }
  180.  
  181.    public Set<Map.Entry<K, V>> entrySet() {
  182.       Set var1 = this.entrySet;
  183.       return var1 != null ? var1 : (this.entrySet = new EntrySet(this, (1)null));
  184.    }
  185.  
  186.    public boolean equals(Object var1) {
  187.       if (!(var1 instanceof EnumMap)) {
  188.          return super.equals(var1);
  189.       } else {
  190.          EnumMap var2 = (EnumMap)var1;
  191.          if (var2.keyType != this.keyType) {
  192.             return this.size == 0 && var2.size == 0;
  193.          } else {
  194.             for(int var3 = 0; var3 < this.keyUniverse.length; ++var3) {
  195.                Object var4 = this.vals[var3];
  196.                Object var5 = var2.vals[var3];
  197.                if (var5 != var4 && (var5 == null || !var5.equals(var4))) {
  198.                   return false;
  199.                }
  200.             }
  201.  
  202.             return true;
  203.          }
  204.       }
  205.    }
  206.  
  207.    public EnumMap<K, V> clone() {
  208.       Object var1 = null;
  209.  
  210.       try {
  211.          var4 = (EnumMap)super.clone();
  212.       } catch (CloneNotSupportedException var3) {
  213.          throw new AssertionError();
  214.       }
  215.  
  216.       var4.vals = var4.vals.clone();
  217.       return var4;
  218.    }
  219.  
  220.    private void typeCheck(K var1) {
  221.       Class var2 = var1.getClass();
  222.       if (var2 != this.keyType && var2.getSuperclass() != this.keyType) {
  223.          throw new ClassCastException(var2 + " != " + this.keyType);
  224.       }
  225.    }
  226.  
  227.    private static <K extends Enum<K>> K[] getKeyUniverse(Class<K> var0) {
  228.       return (K[])SharedSecrets.getJavaLangAccess().getEnumConstantsShared(var0);
  229.    }
  230.  
  231.    private void writeObject(ObjectOutputStream var1) throws IOException {
  232.       var1.defaultWriteObject();
  233.       var1.writeInt(this.size);
  234.  
  235.       for(Map.Entry var3 : this.entrySet()) {
  236.          var1.writeObject(var3.getKey());
  237.          var1.writeObject(var3.getValue());
  238.       }
  239.  
  240.    }
  241.  
  242.    private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  243.       var1.defaultReadObject();
  244.       this.keyUniverse = getKeyUniverse(this.keyType);
  245.       this.vals = new Object[this.keyUniverse.length];
  246.       int var2 = var1.readInt();
  247.  
  248.       for(int var3 = 0; var3 < var2; ++var3) {
  249.          Enum var4 = (Enum)var1.readObject();
  250.          Object var5 = var1.readObject();
  251.          this.put(var4, var5);
  252.       }
  253.  
  254.    }
  255.  
  256.    // $FF: synthetic method
  257.    static int access$200(EnumMap var0) {
  258.       return var0.size;
  259.    }
  260.  
  261.    // $FF: synthetic method
  262.    static Object access$500(EnumMap var0, Object var1) {
  263.       return var0.maskNull(var1);
  264.    }
  265.  
  266.    // $FF: synthetic method
  267.    static Object[] access$600(EnumMap var0) {
  268.       return var0.vals;
  269.    }
  270.  
  271.    // $FF: synthetic method
  272.    static int access$210(EnumMap var0) {
  273.       return var0.size--;
  274.    }
  275.  
  276.    // $FF: synthetic method
  277.    static boolean access$900(EnumMap var0, Object var1, Object var2) {
  278.       return var0.containsMapping(var1, var2);
  279.    }
  280.  
  281.    // $FF: synthetic method
  282.    static boolean access$1000(EnumMap var0, Object var1, Object var2) {
  283.       return var0.removeMapping(var1, var2);
  284.    }
  285.  
  286.    // $FF: synthetic method
  287.    static Enum[] access$1100(EnumMap var0) {
  288.       return var0.keyUniverse;
  289.    }
  290.  
  291.    // $FF: synthetic method
  292.    static Object access$1200(EnumMap var0, Object var1) {
  293.       return var0.unmaskNull(var1);
  294.    }
  295.  
  296.    // $FF: synthetic method
  297.    static Object access$1400() {
  298.       return NULL;
  299.    }
  300. }
  301.